package com.hxzy.system.service.impl;

import com.hxzy.common.constant.Constants;
import com.hxzy.common.constant.UserConstants;
import com.hxzy.common.core.domain.entity.Menu;
import com.hxzy.common.utils.StringUtils;
import com.hxzy.system.mapper.MenuMapper;
import com.hxzy.system.service.MenuService;
import com.hxzy.system.vo.MenuTreeVo;
import com.hxzy.system.vo.MetaVo;
import com.hxzy.system.vo.RouterVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

@Service
@Transactional(rollbackFor = Exception.class)
public class MenuServiceImpl extends CommonServiceImpl<Menu,Long> implements MenuService {

    private MenuMapper menuMapper;
    @Autowired
    public void setMenuMapper(MenuMapper menuMapper) {
        this.menuMapper = menuMapper;
        super.setMyBatisBaseDao(menuMapper);
    }

    @Override
    public List<Menu> selectAllMenu() {
        return this.menuMapper.selectAllMenu();
    }

    /**
     * 根据用户ID查询权限(sys_user,sys_role,sys_menu连在一起)
     * @param userId 用户ID
     * @return
     */
    @Override
    public Set<String> selectMenuPermsByUserId(Long userId) {
        return this.menuMapper.selectMenuPermsByUserId(userId);
    }

    /**
     * 查询菜单(M,C)，构造树型节点
     * @param userId
     * @return
     */
    @Override
    public List<MenuTreeVo> selectMenuTreeByUserId(Long userId) {
        List<MenuTreeVo> menuTreeVoList=new ArrayList<>();

        List<Menu> menuList = this.menuMapper.selectMenuTreeByUserId(userId);

        //遍历第一级
        menuList.stream().filter(p->p.getParentId().equals(0L)).forEach(p-> {
            MenuTreeVo  treeVo=new MenuTreeVo();
            BeanUtils.copyProperties(p,treeVo);

            //加载第二级
            recursionChildren(treeVo,menuList);

            menuTreeVoList.add(treeVo);
        });
        return menuTreeVoList;
    }

    /**
     * 递归子节点
     * @param parent
     * @param menuList
     */
    private void recursionChildren(MenuTreeVo  parent, List<Menu> menuList){
        List<MenuTreeVo> menuTreeVoList=new ArrayList<>();

        menuList.stream().filter(p-> p.getParentId().equals(parent.getMenuId())).forEach(p-> {
            MenuTreeVo  children=new MenuTreeVo();
            BeanUtils.copyProperties(p,children);
            //递归
            recursionChildren(children,menuList);

            menuTreeVoList.add(children);

        });
        if(menuTreeVoList.size()>0){
            parent.setChildren(menuTreeVoList);
        }
    }

    @Override
    public List<RouterVo> buildMenus(List<MenuTreeVo> menus) {

        List<RouterVo> routers = new LinkedList<RouterVo>();

            for (MenuTreeVo menu : menus)
            {
                RouterVo router = new RouterVo();
                router.setHidden("1".equals(menu.getVisible()));
                router.setName(getRouteName(menu));
                router.setPath(getRouterPath(menu));
                router.setComponent(getComponent(menu));
                router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache())));
                List<MenuTreeVo> cMenus = menu.getChildren();
                if (cMenus!=null && cMenus.size() > 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType()))
                {
                    router.setAlwaysShow(true);
                    router.setRedirect("noRedirect");
                    router.setChildren(buildMenus(cMenus));
                }
                else if (isMenuFrame(menu))
                {
                    List<RouterVo> childrenList = new ArrayList<RouterVo>();
                    RouterVo children = new RouterVo();
                    children.setPath(menu.getPath());
                    children.setComponent(menu.getComponent());
                    children.setName(StringUtils.capitalize(menu.getPath()));
                    children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache())));
                    childrenList.add(children);
                    router.setChildren(childrenList);
                }
                routers.add(router);
            }
            return routers;


    }


    /**
     * 获取路由名称
     *
     * @param menu 菜单信息
     * @return 路由名称
     */
    public String getRouteName(MenuTreeVo menu)
    {
        String routerName = StringUtils.capitalize(menu.getPath());
        // 非外链并且是一级目录（类型为目录）
        if (isMenuFrame(menu))
        {
            routerName = StringUtils.EMPTY;
        }
        return routerName;
    }

    /**
     * 获取路由地址
     *
     * @param menu 菜单信息
     * @return 路由地址
     */
    public String getRouterPath(MenuTreeVo menu)
    {
        String routerPath = menu.getPath();
        // 内链打开外网方式
        if (menu.getParentId().intValue() != 0 && isInnerLink(menu))
        {
            routerPath = StringUtils.replaceEach(routerPath, new String[] { Constants.HTTP, Constants.HTTPS }, new String[] { "", "" });
        }
        // 非外链并且是一级目录（类型为目录）
        if (0 == menu.getParentId().intValue() && UserConstants.TYPE_DIR.equals(menu.getMenuType())
                && UserConstants.NO_FRAME.equals(menu.getIsFrame()))
        {
            routerPath = "/" + menu.getPath();
        }
        // 非外链并且是一级目录（类型为菜单）
        else if (isMenuFrame(menu))
        {
            routerPath = "/";
        }
        return routerPath;
    }

    /**
     * 获取组件信息
     *
     * @param menu 菜单信息
     * @return 组件信息
     */
    public String getComponent(MenuTreeVo menu)
    {
        String component = UserConstants.LAYOUT;
        if (StringUtils.isNotEmpty(menu.getComponent()) && !isMenuFrame(menu))
        {
            component = menu.getComponent();
        }
        else if (StringUtils.isEmpty(menu.getComponent()) && menu.getParentId().intValue() != 0 && isInnerLink(menu))
        {
            component = UserConstants.INNER_LINK;
        }
        else if (StringUtils.isEmpty(menu.getComponent()) && isParentView(menu))
        {
            component = UserConstants.PARENT_VIEW;
        }
        return component;
    }

    /**
     * 是否为菜单内部跳转
     *
     * @param menu 菜单信息
     * @return 结果
     */
    public boolean isMenuFrame(MenuTreeVo menu)
    {
        return menu.getParentId().intValue() == 0 && UserConstants.TYPE_MENU.equals(menu.getMenuType())
                && menu.getIsFrame().equals(UserConstants.NO_FRAME);
    }

    /**
     * 是否为内链组件
     *
     * @param menu 菜单信息
     * @return 结果
     */
    public boolean isInnerLink(MenuTreeVo menu)
    {
        return menu.getIsFrame().equals(UserConstants.NO_FRAME) && StringUtils.ishttp(menu.getPath());
    }

    /**
     * 是否为parent_view组件
     *
     * @param menu 菜单信息
     * @return 结果
     */
    public boolean isParentView(MenuTreeVo menu)
    {
        return menu.getParentId().intValue() != 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType());
    }

}
